import express, { Request, Response, Router } from 'express';
import * as bcrypt from 'bcrypt';
import jwt from 'jsonwebtoken';
import { PrismaClient } from '@prisma/client';
import { authMiddleware } from '../middleware/auth';
import { ApiResponse } from '../utils/response';
import { getTierDailyRate } from '../utils/tierHelper';
import { getClientIp } from '../utils/ipHelper';

const router: Router = express.Router();
const prisma = new PrismaClient();

// JWT密钥
const JWT_SECRET = process.env.JWT_SECRET || 'korea-financial-system-secret-key';

// 注册接口
router.post('/register', async (req: Request, res: Response): Promise<void> => {
  try {
    const {
      idNumber,
      username,
      name,
      birthDateFirst6,
      password,
      withdrawalBank,
      withdrawalAccount,
      accountHolder,
      mobileCarrier,
      mobileNumber,
      entryCode,
      referralCode
    } = req.body;

    // 验证必填字段（entryCode 改为可选）
    if (!idNumber || !name || !birthDateFirst6 || !password ||
        !withdrawalBank || !withdrawalAccount || !accountHolder ||
        !mobileCarrier || !mobileNumber) {
      res.status(400).json(ApiResponse.error('모든 필드는 필수 입력 항목입니다.'));
      return;
    }

    // 验证주민등록번호格式 (简单验证)
    if (idNumber.length < 6) {
      res.status(400).json(ApiResponse.error('주민등록번호 형식이 올바르지 않습니다.'));
      return;
    }

    // 验证出生日期格式
    const birthDateRegex = /^\d{6}$/;
    if (!birthDateRegex.test(birthDateFirst6)) {
      res.status(400).json(ApiResponse.error('생년월일 형식이 올바르지 않습니다. 6자리 숫자로 입력해 주세요.'));
      return;
    }

    // 验证휴대폰 번호格式
    const mobileRegex = /^010-?\d{4}-?\d{4}$/;
    if (!mobileRegex.test(mobileNumber)) {
      res.status(400).json(ApiResponse.error('휴대폰 번호 형식이 올바르지 않습니다.'));
      return;
    }

    // 检查주민등록번호是否已存在
    const existingUser = await prisma.user.findUnique({
      where: { idNumber }
    });

    if (existingUser) {
      res.status(400).json(ApiResponse.error('해당 주민등록번호는 이미 등록되었습니다.'));
      return;
    }

    // 验证推荐码（如果提供了）
    let referrerId: number | null = null;
    if (referralCode && referralCode.trim()) {
      const referrer = await prisma.user.findUnique({
        where: { referralCode: referralCode.trim() }
      });

      if (!referrer) {
        res.status(400).json(ApiResponse.error('유효하지 않은 추천 코드입니다.'));
        return;
      }

      if (referrer.status !== 'ACTIVE') {
        res.status(400).json(ApiResponse.error('추천인 계정 상태가 비정상입니다.'));
        return;
      }

      referrerId = referrer.id;
    }

    // 检查 entryCode 是否是合作伙伴的邀请码
    let partnerAdminId: number | null = null;
    if (entryCode && entryCode.trim()) {
      const partnerAdmin = await prisma.admin.findUnique({
        where: {
          partnerCode: entryCode.trim()
        }
      });

      if (partnerAdmin && partnerAdmin.isPartner && partnerAdmin.status === 'ACTIVE') {
        partnerAdminId = partnerAdmin.id;
      }
    }

    // 加密密码
    const saltRounds = 12;
    const hashedPassword = await bcrypt.hash(password, saltRounds);

    // 创建用户
    const user = await prisma.user.create({
      data: {
        idNumber,
        username: username || null,
        name,
        birthDateFirst6,
        password: hashedPassword,
        withdrawalBank,
        withdrawalAccount,
        accountHolder,
        mobileCarrier,
        mobileNumber,
        entryCode: entryCode || null, // entryCode 可选
        referredBy: referrerId, // 设置推荐人ID
        partnerAdminId: partnerAdminId, // 设置所属合作伙伴ID
        status: 'ACTIVE'
      }
    });

    // 使用idNumber作为推荐码
    await prisma.user.update({
      where: { id: user.id },
      data: { referralCode: user.idNumber }
    });

    // 创建用户余额记录（初始KRW余额为0）
    await prisma.userBalance.create({
      data: {
        userId: user.id,
        balance: 0,
        frozen: 0,
        total: 0
      }
    });

    // 🎁 注册赠送：自动创建质押记录，赠送100 NEAR
    // 获取新用户默认等级(ENTRY)的收益率
    const entryDailyRate = await getTierDailyRate('ENTRY')

    // 计算注册用户的首次收益发放时间（2小时后）
    const now = new Date()
    const firstDistributionTime = new Date(now.getTime() + 2 * 60 * 60 * 1000)

    await prisma.userStaking.create({
      data: {
        userId: user.id,
        stakedAmount: 100,           // 赠送100 NEAR质押本金
        lockedAmount: 0,
        totalRewardsNear: 0,         // 初始收益为0
        dailyRewardRate: entryDailyRate, // 使用ENTRY等级的日收益率
        lastSettlementDate: now,     // 设置初始结算日期为注册日
        // 【收益发放初始化】立即初始化收益计算相关字段
        currentDailyReward: 100 * entryDailyRate,  // 当日总收益 = 100 NEAR * 日收益率
        dailyRewardDistributed: 0,                 // 已发放0
        dailyDistributionCount: 0,                 // 发放0次
        nextDistributionAt: firstDistributionTime, // 2小时后开始第一次发放
        lastCalculationDate: now                   // 记录计算时间
      }
    });

    // 生成JWT token
    const token = jwt.sign(
      { 
        userId: user.id, 
        idNumber: user.idNumber 
      },
      JWT_SECRET,
      { expiresIn: '24h' }
    );

    // 返回用户信息（不包含密码）
    const { password: _, ...userWithoutPassword } = user;
    
    res.status(201).json(ApiResponse.success({
      user: userWithoutPassword,
      token
    }, '회원 가입이 완료되었습니다! 환영 선물로 100 NEAR가 스테이킹되었습니다.'));

  } catch (error) {
    console.error('회원 가입 오류:', error);
    res.status(500).json(ApiResponse.error('회원 가입에 실패했습니다. 잠시 후 다시 시도해 주세요.'));
  }
});

// 登录接口
router.post('/login', async (req: Request, res: Response): Promise<void> => {
  try {
    const { idNumber, password } = req.body;

    // 验证必填字段
    if (!idNumber || !password) {
      res.status(400).json(ApiResponse.error('아이디와 비밀번호는 모두 필수 입력입니다.'));
      return;
    }

    // 查找用户
    const user = await prisma.user.findUnique({
      where: { idNumber }
    });

    if (!user) {
      res.status(400).json(ApiResponse.error('아이디 또는 비밀번호가 올바르지 않습니다.'));
      return;
    }

    // 检查用户상태
    if (user.status !== 'ACTIVE') {
      res.status(400).json(ApiResponse.error('계정이 정지되었거나 삭제되었습니다.'));
      return;
    }

    // 验证密码
    const isPasswordValid = await bcrypt.compare(password, user.password);
    if (!isPasswordValid) {
      res.status(400).json(ApiResponse.error('아이디 또는 비밀번호가 올바르지 않습니다.'));
      return;
    }

    // 获取客户端IP地址
    const clientIp = getClientIp(req);

    // 更新最后登录时间和IP
    const now = new Date();
    await prisma.user.update({
      where: { id: user.id },
      data: {
        lastLoginAt: now,
        lastLoginIp: clientIp
      }
    });

    // 生成JWT token
    const token = jwt.sign(
      {
        userId: user.id,
        idNumber: user.idNumber
      },
      JWT_SECRET,
      { expiresIn: '24h' }
    );

    // 返回用户信息（不包含密码，包含更新后的lastLoginAt和lastLoginIp）
    const { password: _, ...userWithoutPassword } = user;
    userWithoutPassword.lastLoginAt = now;
    userWithoutPassword.lastLoginIp = clientIp;

    res.json(ApiResponse.success({
      user: userWithoutPassword,
      token
    }, '로그인에 성공했습니다.'));

  } catch (error) {
    console.error('로그인 오류:', error);
    res.status(500).json(ApiResponse.error('로그인에 실패했습니다. 잠시 후 다시 시도해 주세요.'));
  }
});

// 获取当前用户信息
router.get('/profile', authMiddleware, async (req: Request, res: Response): Promise<void> => {
  try {
    const userId = (req as any).userId;

    const user = await prisma.user.findUnique({
      where: { id: userId },
      select: {
        id: true,
        idNumber: true,
        name: true,
        birthDateFirst6: true,
        withdrawalBank: true,
        withdrawalAccount: true,
        accountHolder: true,
        mobileCarrier: true,
        mobileNumber: true,
        entryCode: true,
        status: true,
        createdAt: true,
        updatedAt: true
      }
    });

    if (!user) {
      res.status(404).json(ApiResponse.error('사용자를 찾을 수 없습니다.'));
      return;
    }

    res.json(ApiResponse.success(user, '사용자 정보 조회에 성공했습니다.'));

  } catch (error) {
    console.error('사용자 정보 조회 오류:', error);
    res.status(500).json(ApiResponse.error('사용자 정보 조회에 실패했습니다.'));
  }
});

// 退出登录
router.post('/logout', authMiddleware, async (req: Request, res: Response): Promise<void> => {
  // JWT是없음상태的，客户端删除token即可
  res.json(ApiResponse.success(null, '로그아웃이 완료되었습니다.'));
});

export default router;